<!DOCTYPE html>

<html class="no-js">

<head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <title>数据结构与算法练习</title>
    <style>
        b {
            display: inline-block;
            width: 80px;
        }

        span {
            display: inline-block;
            width: 255px;
        }
    </style>
</head>

<body>
    <h3>1. 时间复杂度</h3>
    <ul>
        <li>一个算法的时间复杂度反映了程序运行从开始到结束所需要的时间。把算法中基本操作重复执行的次数（频度）作为算法的时间复杂度</li>
    </ul>
    <h4>1.1 常见的时间复杂度有：</h4>
    <ul>
        <li><b>O(1)</b><span>: Constant Complexity: Constant</span>常数复杂度</li>
        <li><b>O(n)</b><span>: Linear Complexity</span>线性时间复杂度</li>
        <li><b>O(log n)</b><span>: Logarithmic Complexity</span>对数复杂度</li>
        <li><b>O(n^2)</b><span>: N square Complexity</span>平⽅方</li>
        <li><b>O(n^3)</b><span>: N square Complexity</span>⽴立⽅方</li>
        <li><b>O(2^n)</b><span>: Exponential Growth</span>指数</li>
        <li><b>O(n!)</b><span>: Factorial </span>阶乘</li>
    </ul>
    <ul>
        <li>注：没有循环语句，记作O(1)，也称为常数阶。只有一重循环，则算法的基本操作的执行频度与问题规模n呈线性增大关系，记作O（n），也叫线性阶</li>
    </ul>

    <img src="./img/1.png" alt="" />

    <h3>2. 空间复杂度</h3>
    <ul>
        <li>一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。</li>
    </ul>

    <h3>3. 数据结构</h3>
    <ul>
        <li>数据结构即数据元素相互之间存在的一种和多种特定的关系集合。</li>
    </ul>

    <h4>3.1 逻辑结构</h4>

    <ol>
        <li> 线性结构
            <ul>
                <li>线性结构：是一个有序数据元素的集合。 其中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的</li>
                <li>常用的线性结构有: 栈，队列，链表，线性表。</li>
            </ul>
        </li>
        <li> 非线性结构
            <ul>
                <li>非线性结构：各个数据元素不再保持在一个线性序列中，每个数据元素可能与零个或者多个其他数据元素发生联系</li>
                <li>常见的非线性结构有 二维数组，树等。</li>
            </ul>
        </li>
    </ol>
    <h4>3.2 存储结构</h4>
    <ul>
        <li>逻辑结构指的是数据间的关系，而存储结构是逻辑结构用计算机语言的实现。常见的存储结构有顺序存储、链式存储、索引存储以及散列存储</li>
    </ul>

    <!-- <script src="js/冒泡排序.js"></script>
    <script src="js/选择排序.js"></script>
    <script src="js/插入排序.js"></script> -->
    <script>
        let arr = [1, 2, 3, 4, 5, 1, 5, 4];
        let num = arr.reduce((prev, cur) => {
            return prev * cur;
        }, 1);
        let _arr = arr.reduceRight((prev, cur) => {
            prev.push(cur);
            return prev;
        }, []);

        function Reverse(arr = []) {
            return arr.reduceRight((t, v) => (t.push(v), t), []);
        }

        let _map = arr.reduce((t, v) => {
            return [...t, v * 2];
        }, []);

        let _filter = arr.reduce((t, v) => {
            return v > 1 ? [...t, v * 2] : t;
        }, []);

        let _set = arr.reduce((t, v) => (t.includes(v) ? t : [...t, v]), []);

        let _max = arr.reduce((t, v) => (t > v ? t : v));

        let _min = arr.reduce((t, v) => (t < v ? t : v));

        console.log(num);
        console.log(_arr);
        console.log(_map);
        console.log(_filter);
        console.log(_set);
        console.log(_max);
        console.log(_min);
    </script>
</body>

</html>